Fixes for the gdk docs

Make gsk docs build

snapshot: Fix some annoations

gsk: Fix build of 22110ef5a480fbddf9d20f510a64f4524a52718f

GskRenderNode: Use C99 flexible arrays to avoid extra allocation

Instead of a separate allocation for any arrays in the render node
we allocate these as part of the render node itself, using C99
flexible arrays.

This leads to less allocations, which is nice, but the major reason
for this is that it allows us to change the allocation scheme further
in the future. For instance, we want to do stack-like allocation so
that all the render-nodes for an entire frame are allocated in one
(or a few) chunks.

gsk: Add bounds member to RenderNode

Instead of constantly recalculating this (especially recursively for
parents!) we do it only on construction, because everything is
immutable anyway. Also, most nodes had a bounds already and can
use the new parent member instead.

We also do direct access to the node bounds rather than calling
gsk_render_node_get_bounds in various places, which means
we do less copying.

gsk: Drop gsk_render_node_make_immutable, nodes are always immutable

gsk docs: gsk_render_node_iter_get_type doesn't exist anymore

Update Kazakh translation

Update German translation
(cherry picked from commit e0856226c580191805f58d0df10260df6b293df9)

debug: Add GTK_DEBUG=snapshot

This causes the snapshotting algorithm to dump all widget nodes into
their own container node. We then name that group accordingly (ie
"GtkSwitch<0xdeadbeef>") so you can easily see which node belongs where.

The feature is toggleable in the inspector's visual tab.

There's a few problems with it, becuse GtkSnapshot optimized container
nodes away if they are not needed, so we are losing some widgets...

revealer: Implement snapshot()

The revealer needs to clip the child during animations, whcih draw() did
automatically, but snapshot() does not.

API: Export gtk_container_snapshot_child()

It's equivalent to gtk_container_propagate_draw() and then one is
public, too.

debug: Remove pixel-cache debug categories

We have no more pixel cache, so they are kind of useless.

flowbox: Don't emit child-activated while dragging the pointer

https://bugzilla.gnome.org/show_bug.cgi?id=776306

cssimageradial: Handle "partial" gradients correctly

When the first/last color stop is not at 0%/100%, we need to start the
repeating at their offsets and not at 0%/100%.

Attached reftest demonstrates the problem.

searchbar: Implement snapshot()

gadget: Remove gtk_css_gadget_draw()

And with it, remove the draw func from custom gadgets, that has been
NULL everywhere.

All gadgets are snapshot now.

colorswatch: Implement snapshot

roundedbox: Add gtk_rounded_boxes_init_for_style()

Instead of making people intiialize a rectangle and then applying border
radius manually, provide a constructor that does it for them.
While doing that, also allow people to instead request the padding box
or the content box.

Refactor all relevant code to use this new constructor.

gtk: Remove GtkJunctionSides

testgtk: Remove resize grips example

Resize grips are gone. And just showing an empty window is not terribly
exciting.

frame: Implement snapshot()

iconview: Implement snapshot()

cellview: Implement snapshot()

This also adds gtk_cell_area_snapshot().

gsk: Add GskOutsetShadowNode

gsk: Add GskInsetShadowNode

And again lots of shadow code gets copied to GSK. But we're now almost
at a stage where widget-factory does not use cairo nodes anymore.

gsk: Add contains/intersect functions for GskRoundedRect

... and use them.

gsk: Add GskShadowNode

... and make the icon rendering code use it.

This requires moving even more shadow renering code into GSK, but so be
it. At least the "shadows not implemented" warning is now gone!

API: gdk: Add gdk_rgba_is_clear() and gdk_rgba_is_opaque()

I want to use these inside GSK, and I'm not a fan of putting GdkRGBA
APIs into it or duplicating it into GTK.

So public API it is.

gsk: Move gtk/gtkcairoblur.c to gsk/gskcairoblur.c

inspector: Print node type in node properties

gsk: Add GskBorderNode

The node draws a solid CSS border, which can be used to cover everything
but dashed and dotted borders (double, groove, inset, ...).

For different border styles, we overlay multiple nodes and set their
colors to transparent for sides with non-matching styles.

gtk: Remove unused argument from function

gsk: Add gsk_rounded_rect_shrink()

... and replace _gtk_rounded_box_grow() and _gtk_rounded_box_shrink()
with it.

vulkan: Get rid of color in push constants

The color comes in instance data now, no need to abuse push constants
for it.

vulkan: Remove color from push constants

It's now handled by the color pipeline.

vulkan: Pass color rects in instance data

This way, we don't need push constants or per-vertex data, we can render
colored rectangles completely via instance data.

vulkan: Don't pass texture coordinates to the color pipeline

vulkan: Get vertex description from pipeline subclass

vulkan: Split color and blend pipelines

vulkan: Move vertex data tracking to the pipeline subclass

That way, different pipelines can draw different kinds of data.

vulkan: Add GskVulkanBlendPipeline

So far that's just a simple pipeline that doesn't do anything.

vulkan: Make GskVulkanPipeline derivable

menu: Implement snapshot() for the menu code

paned: Implement snapshot()

cssimage: Implement snapshot() for cross-fade

snapshot: Implement gtk_snapshot_push_opacity()

Use it in GtkWidget's opacity handling.

snapshot: Handle NULL returns in pop_and_append()

gsk: Add cross-fade node

And implement stack crossfades with it.

vulkan: Batch upload image barriers together

Doesn't seem to help much though...

vulkan: Add GskVulkanUploader

It's the thing that makes sure pixels end up on the GPU.

vulkan: Split out command pool

This way we can pass the command pool around.
And that allows us to allocate and submitcustom buffers.
And that is necessary to make staging images work.

vulkan: Implement staging-buffer image upload

This is not enabled by default. Use GSK_RENDERING_MODE=staging-buffer to
use the code.

snapshot: Convert Range, Scale, ColorScale

And of course Scrollbar, but that one does no drawing itself.

gsk: Check for NULL in calls to gsk_cairo_node_get_surface()

That function does actually sometimes return NULL and is documented to
do so, so handle that case in the renderers (by omitting the node).

gsk: Implement linear gradient render nodes

gsk: Add blend nodes

Implement blend mode support in GTK background compositing with it.

css: Replace custom blend modes with GskBlendMode

gsk: Add missing blend modes

This brings GSK blend modes in line with the CSS spec.

vulkan: Add infrastructure for multiple pipelines

And use it to draw solid colors with a 2nd pipeline.

vulkan: Split PipelineLayout into its own object

This way, we can share the layout between different pipelines.

vulkan: Split render ops into seperate structs

This makes it a lot clearer which members are relevant for each
different operation.

vulkan: Add infrastructure for push constants

THe code includes fragment push constants for colors, but that code is
so far unused.

cssimage: Port a few more simple ones to snapshots

render: Fall back later when rendering backgrounds

We can now render most backgrounds fine.

gtk: Fix memleaks

It turns out, some simple getters - such as
gdk_drawing_context_get_clip() - love copying things before returning
them.

I guess somebody has to burn cycles...

css: An opaque background does not allow omitting push_group

When the background-clip of the background is smaller than the
background-clip of blended images, not pushing a group is wrong.

Test testing exactly that included.

gsk: Add support for rounded clip rectangles

Also add support to GtkSnapshot, so people can push rounded clips.

roundedbox: Remove _gtk_rounded_box_path()

Use gsk_rounded_rect_path() instead.

That's a private GSK function, be we can just include its header.

roundedbox: Remove _gtk_rounded_box_move()

Use gsk_rounded_rect_offset() instead.

gtk: Remove GtkRoundedBox struct

Use GskRoundedRect instead.

roundedbox: typedef to GskRoundedRect

roundedbox: Use a graphene_size_t for the corners

Obviously, I'm trying to port GtkRoundedBox to GskRoundedRect.

This is the second step on that path.

gtk: Get rid of GtkCssCorner

We have GskCorner now which is identical.

gsk: Add GskRoundedRect

It's essentially a port of GtkRoundedBox to graphene.

viewport: implement snapshot()

stack: Implement snapshot()

This uses the new push()/pop() mechanism to its fullest extent when
implementing transitions. It's fun to inspect the results in the
inspector.

Crossfades don't work yet, they continue using a Cairo fallback.

A side effect of the stack conversion is that widget-factory now uses
snapshots for a lot more things.

snapshot: Work on pushing and popping again

It is now possible to call push() subfunctions for simple container
nodes with just a single child. So you can for example
gtk_snapshot_push_clip() a clip region that all the nodes that get
appended later will then obey.

gtk_snapshot_pop() will then not return a container node, but a clip
node containing the container node (and similar for the transform
example).

This is implemented internally by providing a "collect function" when
pushing that is called when popping to collects all the accumulated
nodes and combine them into the single node that gets returned.

To simplify things even more, gtk_snapshot_pop_and_append() has been
added, which pops the currently pushed node and appends it to the
parent.

The icon rendering code has been converted to this approach.

gsk: Add gsk_clip_node_new()

The node is a simple clipping node: It does a rectangular clip of its
contents.

stack: Don't draw an extra background

The gadget draws a background for us, we don't need another one.

gsk: Replace gsk_render_node_set_opacity()

... with gsk_opacity_node_new().

Also implement support for opacity in gtk_widget_snapshot() using this
new node.

cssimage: Implement snapshot() in the fallback image

cssimage: Use textures in GtkCssImageSurface

We now use textures instead of surfaces and implement the snapshot()
vfunc instead of draw().

cssimage: Implement a fallback draw() vfunc

... that chains into snapshot. This way, we can stop implementing draw()
in GtkCssImage subclasses and focus on snapshot() instead.

snapshot: Make gtk_snapshot_get_renderer() private

Public API doesn't need to be concerned with renderers. Worst case, they
can use NULL instead of the actual renderer.

gsk: Remove gsk_renderer_create_fallback()

Use gsk_render_node_draw() instead.

snapshot: Add API for colors and textures

gsk: Add fallback code to renderers

This code makes renderers fall back to Cairo rendering if they don't
know how to handle a render node's type.

This allows adding new render nodes with impunity.

gsk: Add gsk_color_node_new()

Call gsk_render_node_draw() instead of creating fallback renderers

gsk: Add gsk_render_node_draw()

Draws a node to a given cairo_t. This is mostly intended for fallback
usage.

snapshot: Change how gtk_snapshot_push/pop works

Instead of appending a container node and adding the nodes to it as they
come in, we now collect the nodes until gtk_snapshot_pop() is called and
then hand them out in a container node.

The caller of gtk_snapshot_push() is then responsible for doing whatever
he wants with the created node.

Another addigion is the keep_coordinates flag to gtk_snapshot_push()
which allows callers to keep the current offset and clip region or
discard it. Discarding is useful when doing transforms, keeping it is
useful when inserting effect nodes (like the ones I'm about to add).

snapshot: Handle clip region as part of the state

This is in preparation for further changes.

gsk: gsk_render_node_set_transform() => GskTransformNode

Instead of having a setter for the transform, have a GskTransformNode.

Most of the oprations that GTK does do not require a transform, so it
doesn't make sense to have it as a primary attribute.

Also, changing the transform requires updating the uniforms of the GL
renderer, so we're happy if we can avoid that.

gsK: Move children handling to GskContainerNode

gsk: Remove GskRenderNode::parent

... and all related APIs.

inspector: Prepare TreeModelRenderNode for brave new world

I'm about to move children handling to the container node, which means
the generic code can no longer assume children APIs existing.

So rewrite the treemodel to work without it.

gsk: Remove world matrix support

Use the real transform and compute it manually.

gsk: Remove gsk_render_node_set_bounds()

gsk_render_node_get_bounds() still exists and is computed via vfunc
call:
- containers dynamically compute the bounds from their children
- surface and texture nodes get bounds passed on construction